Cách tích hợp Camoufox với CapSolver để giải CAPTCHA một cách liền mạch

# Cài đặt gói Python
pip install -U camoufox[geoip]

# Tải trình duyệt Camoufox
camoufox fetch

from camoufox.sync_api import Camoufox

with Camoufox(humanize=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

pip install camoufox[geoip] httpx

import asyncio
import httpx
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KHÓA_API_CỦA_BẠN"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """Tạo nhiệm vụ giải CAPTCHA và trả về ID nhiệm vụ."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": task_payload
            }
        )
        result = response.json()
        if result.get("errorId") != 0:
            raise Exception(f"Lỗi CapSolver: {result.get('errorDescription')}")
        return result["taskId"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Kiểm tra kết quả nhiệm vụ cho đến khi giải được hoặc hết thời gian."""
    async with httpx.AsyncClient() as client:
        for _ in range(max_attempts):
            response = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            result = response.json()

            if result.get("status") == "ready":
                return result["solution"]
            elif result.get("status") == "failed":
                raise Exception(f"Thất bại: {result.get('errorDescription')}")

            await asyncio.sleep(1)

    raise TimeoutError("Giải CAPTCHA hết thời gian!")


async def solve_captcha(task_payload: dict) -> dict:
    """Hoàn tất quy trình giải CAPTCHA."""
    task_id = await create_task(task_payload)
    return await get_task_result(task_id)

from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/đường_dẫn/tới/mở_rộng_capsolver"],
    headless=False  # Mở rộng yêu cầu chế độ có giao diện
) as browser:
    page = browser.new_page()
    # Mở rộng sẽ tự động phát hiện và giải CAPTCHA

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KHÓA_API_CỦA_BẠN"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """Giải Cloudflare Turnstile và trả về token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Tạo nhiệm vụ
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "AntiTurnstileTaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        task_id = response.json()["taskId"]

        # Kiểm tra kết quả
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["token"]

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/trang-bảo-mật"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Tìm trong mã nguồn trang

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os="windows"
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Chờ Turnstile tải xong
        await page.wait_for_selector('input[name="cf-turnstile-response"]', timeout=10000)

        # Giải CAPTCHA
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"Nhận được token Turnstile: {token[:50]}...")

        # Chèn token
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

            // Cập nhật callback ẩn nếu có
            const callback = document.querySelector('[data-callback]');
            if (callback) {{
                const callbackName = callback.getAttribute('data-callback');
                if (window[callbackName]) {{
                    window[callbackName]('{token}');
                }}
            }}
        ''')

        # Gửi biểu mẫu
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Đã vượt qua Turnstile thành công!")


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KHÓA_API_CỦA_BẠN"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Giải reCAPTCHA v2 và trả về token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Tạo nhiệm vụ
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV2TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Lỗi: {result.get('errorDescription')}")

        task_id = result["taskId"]

        # Kiểm tra kết quả
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Thất bại: {data.get('errorDescription')}")

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/đăng-nhập"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # Tìm trong mã nguồn trang

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # Chọn ngẫu nhiên hệ điều hành
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Điền các trường biểu mẫu với khoảng thời gian giống người dùng
        await page.fill('input[name="username"]', "user@example.com")
        await asyncio.sleep(0.5)  # Nghỉ ngơi giống người dùng
        await page.fill('input[name="password"]', "password123")

        # Giải CAPTCHA
        print("Giải reCAPTCHA v2...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"Nhận được token: {token[:50]}...")

        # Chèn token vào trường phản hồi reCAPTCHA
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # Gửi biểu mẫu
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Đăng nhập thành công!")


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KHÓA_API_CỦA_BẠN"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Giải reCAPTCHA v3 với hành động và điểm số tối thiểu được chỉ định."""
    import httpx

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV3TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                    "pageAction": action,
                    "minScore": min_score
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Lỗi: {result.get('errorDescription')}")

        task_id = result["taskId"]

        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Thất bại: {data.get('errorDescription')}")

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/tim-kiem"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    async with AsyncCamoufox(
        humanize=2.0,  # Chuyển động chuột tối đa 2 giây
        headless=True,  # Chạy không giao diện cho v3
        geoip=True,  # Phát hiện tự động vị trí từ proxy
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Giải reCAPTCHA v3 với hành động "tim-kiem"
        print("Giải reCAPTCHA v3...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="tim-kiem",
            min_score=0.9  # Yêu cầu điểm số cao
        )

        # Gọi hàm callback với token
        await page.evaluate(f'''
            // Gửi token qua hàm callback của trang

    print("Bypass reCAPTCHA v3 thành công!")

---

## Các Nguyên Tắc Tốt

### 1. Quay vòng proxy với GeoIP

Sử dụng tính năng GeoIP của Camoufox để tự động khớp dấu vân tay với vị trí proxy của bạn:

```python
async with AsyncCamoufox(
    geoip=True,  # Tự động phát hiện từ IP proxy
    proxy={
        "server": "http://proxy.example.com:8080",
        "username": "user",
        "password": "pass"
    }
) as browser:
    # Dấu vân tay sẽ khớp với vị trí địa lý của proxy
    pass

from browserforge.fingerprints import Screen

# Hạn chế đến các kích thước màn hình phổ biến
screen = Screen(
    min_width=1280,
    max_width=1920,
    min_height=720,
    max_height=1080
)

async with AsyncCamoufox(
    os="windows",
    screen=screen,
) as browser:
    pass

import random

async def human_delay():
    """Độ trễ ngẫu nhiên để mô phỏng hành vi con người."""
    await asyncio.sleep(random.uniform(1.0, 3.0))

# Sử dụng giữa các hành động
await page.click('button')
await human_delay()
await page.fill('input', 'text')

async def solve_with_retry(task_payload: dict, max_retries: int = 3) -> dict:
    """Giải CAPTCHA với logic thử lại."""
    for attempt in range(max_retries):
        try:
            return await solve_captcha(task_payload)
        except TimeoutError:
            if attempt < max_retries - 1:
                print(f"Thời gian chờ hết, thử lại... ({attempt + 1}/{max_retries})")
                await asyncio.sleep(5)
            else:
                raise
        except Exception as e:
            if "balance" in str(e).lower():
                raise  # Không thử lại lỗi số dư
            if attempt < max_retries - 1:
                await asyncio.sleep(2)
            else:
                raise